#include "HxMD5.h"

#ifdef XW_BIGENDIAN // UnifiedSource
#  define HIGHFIRST
#endif

#ifndef HIGHFIRST
#  define byteReverse(buf, len)	// Nothing
#else

/*
 * Note: this code is harmless on little-endian machines.
 */
void byteReverse(buf, longs)
    unsigned char *buf; unsigned longs;
{
    uint32 t;
    do {
	t = (uint32) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
	    ((unsigned) buf[1] << 8 | buf[0]);
	*(uint32 *) buf = t;
	buf += 4;
    } while (--longs);
}
#endif


MD5_CTX::MD5_CTX() {
	this->state[0] = 0x67452301;
	this->state[1] = 0xefcdab89;
	this->state[2] = 0x98badcfe;
	this->state[3] = 0x10325476;

	this->count[0] = 0;
	this->count[1] = 0;
}

MD5_CTX::~MD5_CTX() {

}

void MD5_CTX::update(const char *value, unsigned len) {
    uint32 t;

    // Update bitcount
    t = this->count[0];

    if ((this->count[0] = t + ((uint32) len << 3)) < t)
    	this->count[1]++; 	// Carry from low to high

    this->count[1] += len >> 29;

    t = (t >> 3) & 0x3f;	// Bytes already in shsInfo->data

    // Handle any leading odd-sized chunks
    if (t) {
		unsigned char *p = (unsigned char *) this->in + t;

		t = 64 - t;
		if (len < t) {
			memcpy(p, value, len);
			return;
		}
		memcpy(p, value, t);
		byteReverse(this->in, 16);
		HxMD5::MD5Transform(this->state, (uint32 *) this->in);
		//this->transform();
		value += t;
		len -= t;
    }

    // Process data in 64-byte chunks
    while (len >= 64) {
		memcpy(this->in, value, 64);
		byteReverse(this->in, 16);
		HxMD5::MD5Transform(this->state, (uint32 *) this->in);
		//this->transform();
		value += 64;
		len -= 64;
    }

    // Handle any remaining bytes of data.
    memcpy(this->in, value, len);
}

void MD5_CTX::final(unsigned char digest[16]) {

	//unsigned count;
	int count;
	unsigned char *p;

	// Compute number of bytes mod 64
	count = (this->count[0] >> 3) & 0x3F;

	// Set the first char of padding to 0x80.
	// This is safe since there is
	// always at least one byte free

	p = this->in + count;
	*p++ = 0x80;

	count = 56 - 1 - count;

	if (count < 0) {	// Padding forces an extra block
		memset(p, 0, count + 8);
		byteReverse(this->in, 16);
		HxMD5::MD5Transform(this->state, (uint32*) this->in);
		//this->transform();
		p = this->in;
		count = 56;
		memset( p, 0, count);
	}
        //fprintf(stdout,"[final] [%d]\n", count); fflush(stdout);
	memset( p, 0, count);
	//memset( p, 0, min<int>(count, strlen((char*)p)) );

	byteReverse(this->in, 14);

	// Append length in bits and transform
	((uint32 *) this->in)[14] = this->count[0];
	((uint32 *) this->in)[15] = this->count[1];

	HxMD5::MD5Transform(this->state, (uint32 *) this->in);
	//this->transform();

	byteReverse((unsigned char *) this->state, 4);
	memcpy(digest, this->state, 16);

	//memset(ctx, 0, sizeof(ctx)); // In case it's sensitive

}

void HxMD5::md5(const string& what, string& md5) {

        //fprintf(stdout,"md5 di %s\n", (char*) what.c_str() ); fflush(stdout);
	MD5_CTX* sMd5Ctx = new MD5_CTX();
	unsigned char* pcCrc = new unsigned char[MD5EX_CRCSTR_LEN];

	if (!what.empty()){
		sMd5Ctx->update(what.c_str(), (unsigned int)what.size());
		sMd5Ctx->final(pcCrc);
		CRCToString(pcCrc, md5);
	}

        delete [] pcCrc;
	delete sMd5Ctx;
}

void HxMD5::CRCToString(unsigned char* pcCrc, string& dest){
   unsigned char *pcCrcLoop ;
   char result[MD5EX_CRCSTR_LEN + 1];
   char *pc;
   int iIndex ;

   if ( !pcCrc ) dest = "" ;
   else {
      pc = result;
      pc[0] = '\0' ;
      pcCrcLoop = pcCrc ;
      for(iIndex = 0; iIndex < MD5EX_CRCBIN_LEN; ++iIndex, ++pcCrcLoop, pc += 2) {
         sprintf(pc, "%.2X", ((unsigned int)*pcCrcLoop&0x000000FF)) ;
      }
      dest = result;
   }
}

void HxMD5::MD5Transform(uint32 buf[4], uint32 in[16]){
    //register uint32 a, b, c, d;

	uint32 a, b, c, d;

    a = buf[0];
    b = buf[1];
    c = buf[2];
    d = buf[3];

    MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
    MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
    MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
    MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
    MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
    MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
    MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
    MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
    MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
    MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
    MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
    MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
    MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
    MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
    MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
    MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);

    MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
    MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
    MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
    MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
    MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
    MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
    MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
    MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
    MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
    MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
    MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
    MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
    MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
    MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
    MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
    MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);

    MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
    MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
    MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
    MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
    MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
    MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
    MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
    MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
    MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
    MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
    MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
    MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
    MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
    MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
    MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
    MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);

    MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
    MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
    MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
    MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
    MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
    MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
    MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
    MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
    MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
    MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
    MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
    MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
    MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
    MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
    MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
    MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);

    buf[0] += a;
    buf[1] += b;
    buf[2] += c;
    buf[3] += d;
}
